// 导入必要的库
import 'dart:math'; // 用于 Point.distanceBetween

// ========== 类定义 ==========
// 这些类是根据文档中不同片段的示例定义的

// --- Point 类 (根据多个片段组合) ---
// 注意：文档中 Point 类的定义似乎分布在不同示例中，这里尝试整合
class Point {
  // 来自 "Instance variables" 片段
  double x; // 声明实例变量 x
  double y; // 声明实例变量 y
  // double z = 0; // 文档中另一个例子有 z，但为了紧密贴合主要示例，暂时注释掉

  // 来自 "Using constructors" 片段 (假设的构造函数，文档没给出 Point 的完整定义)
  // 为了让 var p = Point(2, 2); 能运行，添加一个构造函数
  Point(this.x, this.y);

  // 来自 "Using class members" 片段 (假设的方法，文档没给出 Point 的完整定义)
  // 为了让 p.distanceTo(...) 能运行，添加一个方法
  double distanceTo(Point other) {
    // 实现基于 x 和 y
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }

  // 来自 "Using constructors" 片段 (假设的命名构造函数)
  // 为了让 Point.fromJson(...) 能运行，添加一个工厂构造函数示例
  // 注意：实际实现可能更复杂
  factory Point.fromJson(Map<String, double> json) {
    return Point(json['x']!, json['y']!);
  }

  // 来自 "Static methods" 片段 (静态方法)
  static double distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }

  // 重写 toString 方便打印
  @override
  String toString() => 'Point(x: $x, y: $y)';
}

// --- ImmutablePoint 类 (来自 "Using constructors" - const 相关片段) ---
class ImmutablePoint {
  final double x;
  final double y;

  const ImmutablePoint(this.x, this.y);

  // 重写 toString 方便打印
  @override
  String toString() => 'ImmutablePoint(x: $x, y: $y)';
}

// --- ProfileMark 类 (来自 "Instance variables" - final 相关片段) ---
class ProfileMark {
  final String name;
  final DateTime start = DateTime.now(); // 直接在声明时初始化 final

  // 构造函数参数初始化 final
  ProfileMark(this.name);

  // 初始化列表初始化 final
  ProfileMark.unnamed() : name = '';

  // 重写 toString 方便打印
  @override
  String toString() => 'ProfileMark(name: $name, start: $start)';
}

// --- Person 和 Impostor 类 (来自 "Implicit interfaces" 片段) ---
// 一个 person. 隐式接口包含 greet().
class Person {
  // 在接口中，但仅在此库中可见.
  final String _name;

  // 不在接口中, 因为这是一个构造函数.
  Person(this._name);

  // 在接口中.
  String greet(String who) => '你好, $who. 我是 $_name.';
}

// Person 接口的一个实现.
class Impostor implements Person {
  // 实现接口要求的 getter (虽然原接口是 final _name)
  // 为了能编译通过，提供一个 getter 实现
  @override
  String get _name => ''; // 或者可以返回一个固定的假名

  // 实现接口要求的 greet 方法
  @override
  String greet(String who) => '嗨 $who. 你知道我是谁吗?';
}

// 辅助函数，用于演示接口
String greetBob(Person person) => person.greet('Bob');

// --- Queue 类 (来自 "Static variables" 片段) ---
class Queue {
  static const initialCapacity = 16;
  // ··· (省略号表示类还有其他成员)
}

// ========== main 函数：执行文档中的示例代码 ==========
void main() {
  print('--- 演示：使用类成员 ---');
  var p = Point(2, 2); // 对应 var p = Point(2, 2);
  print('p 的值: $p');
  assert(p.y == 2); // 对应 assert(p.y == 2);
  print('断言 p.y == 2 通过');
  double distance = p.distanceTo(
    Point(4, 4),
  ); // 对应 double distance = p.distanceTo(Point(4, 4));
  print('p 到 Point(4, 4) 的距离: ${distance.toStringAsFixed(2)}');

  // 对应 var a = p?.y;
  var aNullableY = p.y;
  print('使用 ?. 获取 p 的 y 值: $aNullableY');
  Point? nullPoint; // 创建一个 null 的 Point 引用

  // 修改后的代码片段
  Point? nullablePoint; // 创建一个 null 的 Point 引用
  double? bNullableY = nullPoint?.y; // 显式声明类型
  print('使用 ?. 获取 nullPoint 的 y 值: $bNullableY'); // 输出 null

  print('\n--- 演示：使用构造函数 ---');
  var p1 = Point(2, 2); // 对应 var p1 = Point(2, 2);
  var p2 = Point.fromJson({
    'x': 1,
    'y': 2,
  }); // 对应 var p2 = Point.fromJson({'x': 1, 'y': 2});
  print('p1 (Point(2, 2)): $p1');
  print('p2 (Point.fromJson): $p2');

  // 对应 var p1 = new Point(2, 2); (new 是可选的)
  var p1WithNew = Point(2, 2);
  print('p1_with_new (new Point(2, 2)): $p1WithNew');

  print('\n--- 演示：常量构造函数 ---');
  var pConst = const ImmutablePoint(
    2,
    2,
  ); // 对应 var p = const ImmutablePoint(2, 2);
  print('常量点 p_const: $pConst');

  var aConst = const ImmutablePoint(
    1,
    1,
  ); // 对应 var a = const ImmutablePoint(1, 1);
  var bConst = const ImmutablePoint(
    1,
    1,
  ); // 对应 var b = const ImmutablePoint(1, 1);
  assert(identical(aConst, bConst)); // 对应 assert(identical(a, b));
  print('断言 identical(a_const, b_const) 通过 (它们是同一个实例)');

  // 对应 const pointAndLine = { ... }; (省略 const 的版本)
  const pointAndLine = {
    'point': [ImmutablePoint(0, 0)],
    'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)],
  };
  print('常量 Map (省略内部 const): $pointAndLine');

  var aNonConst = const ImmutablePoint(
    1,
    1,
  ); // 对应 var a = const ImmutablePoint(1, 1);
  var bNonConst = ImmutablePoint(1, 1); // 对应 var b = ImmutablePoint(1, 1);
  assert(!identical(aNonConst, bNonConst)); // 对应 assert(!identical(a, b));
  print('断言 !identical(a_non_const, b_non_const) 通过 (它们不是同一个实例)');

  print('\n--- 演示：获取对象类型 ---');
  // 使用上面创建的 a_const
  print(
    'a_const 的类型是 ${aConst.runtimeType}',
  ); // 对应 print('The type of a is ${a.runtimeType}');

  print('\n--- 演示：实例变量和隐式 Getters/Setters ---');
  // 这个示例在文档中使用了独立的 Point 类定义，这里复用上面的 Point 类
  var pointForSetter = Point(0, 0); // 创建一个 Point 实例
  pointForSetter.x = 4; // 对应 point.x = 4; (使用 setter)
  print('设置 pointForSetter.x = 4');
  assert(pointForSetter.x == 4); // 对应 assert(point.x == 4); (使用 getter)
  print('断言 pointForSetter.x == 4 通过');
  assert(pointForSetter.y == 0); // 对应 assert(point.y == null); (这里 y 初始化为 0 了)
  print('断言 pointForSetter.y == 0 通过 (构造函数初始化了)');

  print('\n--- 演示：final 实例变量 (ProfileMark) ---');
  var mark1 = ProfileMark('MyProfile');
  var mark2 = ProfileMark.unnamed();
  print('创建的 ProfileMark 实例: $mark1, $mark2');

  print('\n--- 演示：隐式接口 (implements) ---');
  print(greetBob(Person('Kathy'))); // 对应 print(greetBob(Person('Kathy')));
  print(greetBob(Impostor())); // 对应 print(greetBob(Impostor()));

  print('\n--- 演示：静态变量 ---');
  assert(
    Queue.initialCapacity == 16,
  ); // 对应 assert(Queue.initialCapacity == 16);
  print('断言 Queue.initialCapacity == 16 通过');
  print('Queue.initialCapacity: ${Queue.initialCapacity}');

  print('\n--- 演示：静态方法 ---');
  var pointA = Point(2, 2); // 对应 var a = Point(2, 2);
  var pointB = Point(4, 4); // 对应 var b = Point(4, 4);
  var distanceStatic = Point.distanceBetween(
    pointA,
    pointB,
  ); // 对应 var distance = Point.distanceBetween(a, b);
  assert(
    2.8 < distanceStatic && distanceStatic < 2.9,
  ); // 对应 assert(2.8 < distance && distance < 2.9);
  print('断言 2.8 < distanceStatic < 2.9 通过');
  print(
    '使用静态方法计算的距离: ${distanceStatic.toStringAsFixed(2)}',
  ); // 对应 print(distance);

  print('\n--- 所有文档示例演示完毕 ---');
}
